import '../models/response/base_response.dart';
import '../providers/base_provider.dart';
import 'package:get/get.dart';
import '../../services/storage/local_storage_service.dart';

/// 基础仓库抽象类
///
/// 所有仓库的基类，提供基本的数据操作功能
abstract class BaseRepository<T extends BaseProvider> {
  /// 数据提供者
  final T provider;
  
  /// 构造函数
  const BaseRepository(this.provider);
  
  /// 处理响应结果
  R handleResponse<R, D>(
    BaseResponse<D> response, {
    R Function(D data)? onSuccess,
    R Function(String message, String code)? onError,
    R Function()? onEmpty,
  }) {
    if (response.isSuccess && response.data != null) {
      return onSuccess != null
          ? onSuccess(response.data as D)
          : response.data as R;
    } else if (response.isSuccess && response.data == null) {
      return onEmpty != null ? onEmpty() : null as R;
    } else {
      return onError != null
          ? onError(response.message, response.code)
          : null as R;
    }
  }
  
  /// 获取分页数据
  Future<Pagination<R>> getPagination<R, D>({
    required Future<BaseResponse<Pagination<D>>> Function() request,
    required R Function(D) converter,
    R Function(String message, String code)? onError,
  }) async {
    final response = await request();
    
    if (response.isSuccess && response.data != null) {
      final pagination = response.data as Pagination<D>;
      final items = pagination.items.map(converter).toList();
      
      return Pagination<R>(
        current: pagination.current,
        pageSize: pagination.pageSize,
        total: pagination.total,
        items: items,
      );
    } else {
      if (onError != null) {
        onError(response.message, response.code);
      }
      
      return Pagination<R>.empty();
    }
  }

  // 可以注入通用的 Provider 或 Service
  // 例如，如果所有仓库都需要访问本地存储
  final LocalStorageService storageService = Get.find<LocalStorageService>();

  // 示例：通用的网络检查（如果需要）
  // final ConnectivityService connectivityService = Get.find<ConnectivityService>();

  /// 检查网络连接状态（示例）
  // Future<bool> isConnected() async {
  //   return await connectivityService.checkConnectivity() != 'none';
  // }

  /// 尝试从缓存获取数据，如果失败则从网络获取（示例）
  // Future<T?> fetchWithCache<T>(
  //   String cacheKey,
  //   Future<T?> Function() networkFetch,
  //   T? Function(dynamic cachedData) fromCache,
  //   dynamic Function(T data) toCache,
  //   {Duration expiry = const Duration(minutes: 5)}
  // ) async {
  //   // 1. 检查缓存
  //   final cachedData = storageService.read(cacheKey);
  //   if (cachedData != null && !storageService.isExpired(cacheKey)) {
  //     try {
  //       return fromCache(cachedData);
  //     } catch (e) {
  //       // 缓存解析失败，忽略
  //     }
  //   }
    
  //   // 2. 检查网络
  //   if (!await isConnected()) {
  //     // 无网络且缓存无效或不存在
  //     return null; 
  //   }
    
  //   // 3. 从网络获取
  //   try {
  //     final networkData = await networkFetch();
  //     if (networkData != null) {
  //       // 缓存结果
  //       await storageService.write(cacheKey, toCache(networkData));
  //       await storageService.setExpiry(cacheKey, expiry);
  //       return networkData;
  //     }
  //     return null;
  //   } catch (e) {
  //     // 网络请求失败
  //     // 可以选择返回旧的缓存数据（即使已过期）作为备用
  //     if (cachedData != null) {
  //        try {
  //          return fromCache(cachedData);
  //        } catch (_) {}
  //     }
  //     rethrow; // 或抛出错误
  //   }
  // }
} 